home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / Onboard / utils.py < prev   
Encoding:
Python Source  |  2009-10-01  |  11.1 KB  |  368 lines
  1. #!/usr/bin/python
  2. # -*- coding: utf-8 -*-
  3.  
  4. import os
  5. import string
  6.  
  7. import gtk
  8.  
  9. from xml.dom import minidom
  10. from copy import deepcopy
  11.  
  12. from Onboard.KeyGtk import *
  13. from Onboard import KeyCommon
  14.  
  15. ### Config Singleton ###
  16. from Onboard.Config import Config
  17. config = Config()
  18. ########################
  19.  
  20. modifiers = {"shift":1,
  21.              "caps":2,
  22.              "control":4,
  23.              "mod1":8,
  24.              "mod2":16,
  25.              "mod3":32,
  26.              "mod4":64,
  27.              "mod5":128}
  28.  
  29.  
  30. modDic = {"LWIN" : ("Win",64),
  31.           "RTSH" : ("Γçº".decode('utf-8'), 1),
  32.           "LFSH" : ("Γçº".decode('utf-8'), 1),
  33.           "RALT" : ("Alt Gr", 128),
  34.           "LALT" : ("Alt", 8),
  35.           "RCTL" : ("Ctrl", 4),
  36.           "LCTL" : ("Ctrl", 4),
  37.           "CAPS" : ("CAPS", 2),
  38.           "NMLK" : ("Nm\nLk",16)}
  39.  
  40. otherDic = {"RWIN" : "Win",
  41.             "MENU" : "Menu",
  42.             "BKSP" : "Γçª".decode("utf-8"),
  43.             "RTRN" : "Return",
  44.             "TAB" : "Tab",
  45.             "INS":"Ins",
  46.             "HOME":"Hm",
  47.             "PGUP": "Pg\nUp",
  48.             "DELE":"Del",
  49.             "END":"End",
  50.             "PGDN":"Pg\nDn",
  51.             "UP":  "Γåæ".decode("utf-8"),
  52.             "DOWN":"Γåô".decode("utf-8"),
  53.             "LEFT" : "ΓåÉ".decode("utf-8"),
  54.             "RGHT" : "ΓåÆ".decode("utf-8"),
  55.             "KP0" : "0",
  56.             "KP1" : "1",
  57.             "KP2" : "2",
  58.             "KP3" : "3",
  59.             "KP4" : "4",
  60.             "KP5" : "5",
  61.             "KP6" : "6",
  62.             "KP7" : "7",
  63.             "KP8" : "8",
  64.             "KP9" : "9",
  65.             "KPDL":"Del",
  66.             "KPEN": "Ent" }
  67.  
  68. funcKeys = (("ESC",65307),
  69.             ("F1",65470),
  70.             ("F2",65471),
  71.             ("F3",65472),
  72.             ("F4", 65473),
  73.             ("F5", 65474),
  74.             ("F6",65475),
  75.             ("F7",65476),
  76.             ("F8",65477),
  77.             ("F9",65478),
  78.             ("F10",65479),
  79.             ("F11", 65480),
  80.             ("F12", 65481),
  81.             ("Prnt", 65377),
  82.             ("Scroll", 65300),
  83.             ("Pause", 65299))
  84.  
  85. keysyms = {"space" : 65408,
  86.            "insert" : 0xff9e,
  87.            "home" : 0xff50,
  88.            "page_up" : 0xff55,
  89.            "page_down" : 0xff56,
  90.            "end" :0xff57,
  91.            "delete" : 0xff9f,
  92.            "return" : 65293,
  93.            "backspace" : 65288,
  94.            "left" : 0xff51,
  95.            "up" : 0xff52,
  96.            "right" : 0xff53,
  97.            "down" : 0xff54,}
  98.  
  99. def get_keysym_from_name(name):
  100.     return keysyms[name]
  101.  
  102. def run_script(script):
  103.     a =__import__(script)
  104.     a.run()
  105.  
  106. def create_layout_XML(name, vk, keyboard):
  107.     "Reads layout stored within onBoard and outputs it to XML"
  108.     doc = minidom.Document()
  109.  
  110.     keyboard_element = doc.createElement("keyboard")
  111.     keyboard_element.setAttribute("id", name)
  112.     doc.appendChild(keyboard_element)
  113.  
  114.  
  115.     f = open(os.path.join(config.install_dir, "layouts","template.svg"))
  116.     baseDoc = minidom.parse(f)
  117.     f.close()
  118.  
  119.     paneDocs = []
  120.     for pane in keyboard.panes:
  121.         paneDoc = deepcopy(baseDoc)
  122.         paneDocs.append(paneDoc)
  123.     
  124.     _create_pane_xml(keyboard.basePane, doc, baseDoc, vk, name)
  125.     
  126.     for i in range(len(paneDocs)):
  127.         _create_pane_xml(keyboard.panes[i], doc, paneDocs[i], vk, name)
  128.             
  129.     
  130.     #messy
  131.     docFile = open(os.path.join(os.path.expanduser("~"), ".sok", "layouts",
  132.         "%s.sok" % name), 'w')
  133.     docFile.write(doc.toxml())
  134.     docFile.close()
  135.     
  136.     docFile = open(os.path.join(os.path.expanduser("~"),
  137.         ".sok", "layouts", "%s-%s.svg" % (name, keyboard.basePane.ident)), 'w')
  138.     docFile.write(baseDoc.toxml())
  139.     docFile.close()
  140.     
  141.     for i in range(len(paneDocs)):
  142.         docFile = open(os.path.join(os.path.expanduser("~"),".sok",
  143.             "layouts", "%s-%s.svg" % (name, keyboard.panes[i].ident)), 'w')
  144.         docFile.write(paneDocs[i].toxml())
  145.         docFile.close()
  146.             
  147.                                                     
  148.     
  149. def _create_pane_xml(pane, doc, svgDoc, vk, name):
  150.     """
  151.     @type   pane: Onboard.Pane.Pane
  152.     @param  pane: Pane object that we are creating xml for.
  153.  
  154.     @type   doc: xml.dom.minidom.Document
  155.     @param  doc: DOM of .sok layout file.
  156.  
  157.     @type   svgDoc: xml.dom.minidom.Document.
  158.     @param  svgDoc: DOM of this panes SVG file.
  159.  
  160.     @type   vk:     Virtkey.Virtkey
  161.  
  162.     @type   name:   str
  163.     @param  name:   Name of layout to be created.
  164.  
  165.     """
  166.  
  167.     config_element  = _make_pane_config_xml(doc, pane.ident, 
  168.                         "%s-%s.svg" % (name,pane.ident),pane.rgba,pane.fontSize)
  169.  
  170.     doc.documentElement.appendChild(config_element)
  171.  
  172.     svgDoc.documentElement.setAttribute("width", str(pane.viewPortSizeX))
  173.     svgDoc.documentElement.setAttribute("height", str(pane.viewPortSizeY))
  174.  
  175.     for keyKey,keyVal in pane.keys.items():
  176.         if keyVal.__class__ == RectKey:
  177.             svgDoc.documentElement.appendChild(make_xml_rect(doc,
  178.                                             keyKey,
  179.                                             keyVal.x,
  180.                                             keyVal.y,
  181.                                             keyVal.width,
  182.                                             keyVal.height,
  183.                                             keyVal.rgba))
  184.         
  185.             config_element.appendChild(_make_key_xml(doc, keyKey, keyVal))
  186.             
  187.         elif keyVal.__class__ == LineKey:
  188.             print "funky keys not yet implemented"
  189.         
  190.         
  191.  
  192. def _make_pane_config_xml(doc,ident,filename,rgba,font):        
  193.     
  194.     pane_element = doc.createElement("pane")
  195.     
  196.     pane_element.setAttribute("id", ident)
  197.     pane_element.setAttribute("filename", filename)
  198.     pane_element.setAttribute("backgroundRed", str(rgba[0]))
  199.     pane_element.setAttribute("backgroundGreen", str(rgba[1]))
  200.     pane_element.setAttribute("backgroundBlue", str(rgba[2]))
  201.     pane_element.setAttribute("backgroundAlpha", str(rgba[3]))
  202.     pane_element.setAttribute("font", str(font))
  203.     
  204.     return pane_element
  205.     
  206. def make_xml_rect(doc,ident,x,y,width,height,rgba):
  207.     rect_element = doc.createElement("rect")
  208.         
  209.     rect_element.setAttribute("id",ident)
  210.     rect_element.setAttribute("x",str(x))
  211.     rect_element.setAttribute("y",str(y))
  212.     rect_element.setAttribute("width",str(width))
  213.     rect_element.setAttribute("height",str(height))
  214.  
  215.     rect_element.setAttribute("style","fill:#%s%s%s;stroke:#000000;" % (dec_to_hex_colour(rgba[0]),
  216.                                                             dec_to_hex_colour(rgba[1]),dec_to_hex_colour(rgba[2])))
  217.     
  218.     return rect_element
  219.  
  220. def dec_to_hex_colour(dec):
  221.     hexString = hex(int(255*dec))[2:]   
  222.     if len(hexString) == 1:
  223.         hexString = "0" + hexString
  224.         
  225.     return hexString
  226.         
  227.  
  228.  
  229. def _make_key_xml(doc, ident, key):
  230.  
  231.     key_element = doc.createElement("key")
  232.  
  233.     if ident in otherDic:
  234.         key_element.setAttribute("label", otherDic[ident]);
  235.  
  236.     if key.action_type != KeyCommon.KEYCODE_ACTION:
  237.         if key.labels:
  238.             if key.labels[0]:
  239.                 key_element.setAttribute("label",key.labels[0])
  240.             if key.labels[1]:
  241.                 key_element.setAttribute("cap_label",key.labels[1])
  242.             if key.labels[2]:
  243.                 key_element.setAttribute("shift_label",key.labels[2])
  244.             if key.labels[3]:
  245.                 key_element.setAttribute("altgr_label",key.labels[3])
  246.             if key.labels[4]:
  247.                 key_element.setAttribute("altgrNshift_label",key.labels[4])
  248.     
  249.     key_element.setAttribute("id",ident)
  250.         
  251.     if key.action_type == KeyCommon.CHAR_ACTION:
  252.         key_element.setAttribute("char", key.action)
  253.     elif key.action_type == KeyCommon.KEYSYM_ACTION:
  254.         key_element.setAttribute("keysym", str(key.action))
  255.     elif key.action_type == KeyCommon.KEYPRESS_NAME_ACTION:
  256.         key_element.setAttribute("keypress_name", str(key.action))
  257.     elif key.action_type == KeyCommon.KEYCODE_ACTION:
  258.         key_element.setAttribute("keycode", str(key.action))
  259.     elif key.action_type == KeyCommon.MODIFIER_ACTION:
  260.         for k,val in modifiers.items():
  261.             if key.action == val:
  262.                 key_element.setAttribute("modifier", k)
  263.     elif key.action_type == KeyCommon.MACRO_ACTION:
  264.         key_element.setAttribute("macro", str(key.action))
  265.     elif key.action_type == KeyCommon.SCRIPT_ACTION:
  266.         key_element.setAttribute("script", key.action)
  267.  
  268.     if key.fontOffsetX:
  269.         key_element.setAttribute("font_offset_x", key.fontOffsetX)
  270.  
  271.     if key.fontOffsetY:
  272.         key_element.setAttribute("font_offset_y", key.fontOffsetY)
  273.  
  274.     if key.sticky:
  275.         key_element.setAttribute("sticky", "true")
  276.     else:
  277.         key_element.setAttribute("sticky", "false") 
  278.  
  279.  
  280.     return key_element
  281.  
  282.  
  283. def matmult(m, v):
  284.     """ Matrix-vector multiplication """
  285.     nrows = len(m)
  286.     w = [None] * nrows
  287.     for row in range(nrows):
  288.         w[row] = reduce(lambda x,y: x+y, map(lambda x,y: x*y, m[row], v))
  289.     return w
  290.             
  291. def hexstring_to_float(hexString): 
  292.     return float(string.atoi(hexString,16))
  293.  
  294. class dictproperty(object):
  295.     """ Property implementation for dictionaries """
  296.  
  297.     class _proxy(object):
  298.  
  299.         def __init__(self, obj, fget, fset, fdel):
  300.             self._obj = obj
  301.             self._fget = fget
  302.             self._fset = fset
  303.             self._fdel = fdel
  304.  
  305.         def __getitem__(self, key):
  306.             if self._fget is None:
  307.                 raise TypeError, "can't read item"
  308.             return self._fget(self._obj, key)
  309.  
  310.         def __setitem__(self, key, value):
  311.             if self._fset is None:
  312.                 raise TypeError, "can't set item"
  313.             self._fset(self._obj, key, value)
  314.  
  315.         def __delitem__(self, key):
  316.             if self._fdel is None:
  317.                 raise TypeError, "can't delete item"
  318.             self._fdel(self._obj, key)
  319.  
  320.     def __init__(self, fget=None, fset=None, fdel=None, doc=None):
  321.         self._fget = fget
  322.         self._fset = fset
  323.         self._fdel = fdel
  324.         self.__doc__ = doc
  325.  
  326.     def __get__(self, obj, objtype=None):
  327.         if obj is None:
  328.             return self
  329.         return self._proxy(obj, self._fget, self._fset, self._fdel)
  330.  
  331. def show_error_dialog(error_string):
  332.     """ Show an error dialog """
  333.  
  334.     error_dlg = gtk.MessageDialog(type=gtk.MESSAGE_ERROR, 
  335.                                   message_format=error_string,
  336.                                   buttons=gtk.BUTTONS_OK)
  337.     error_dlg.run()
  338.     error_dlg.destroy() 
  339.  
  340. def show_question_dialog(question):
  341.     question_dialog = gtk.MessageDialog(type=gtk.MESSAGE_QUESTION, 
  342.                                         buttons=gtk.BUTTONS_OK_CANCEL)
  343.     question_dialog.set_markup(question)
  344.     entry = gtk.Entry()
  345.     entry.connect("activate", lambda event:
  346.         question_dialog.response(gtk.RESPONSE_OK))
  347.     question_dialog.vbox.pack_end(entry)
  348.     question_dialog.show_all()
  349.     response = question_dialog.run()
  350.     question_dialog.destroy()
  351.     if response == gtk.RESPONSE_OK: return entry.get_text()
  352.     
  353. if __name__=='__main__':
  354.     
  355.     from sys import argv
  356.     
  357.     
  358.     if argv[0]:
  359.         from virtkey import virtkey
  360.         from sok import Sok
  361.         s = Sok()
  362.         vk = virtkey()
  363.         create_layout_XML(argv[0],vk,s)
  364.     else:
  365.         print "Type name for personalised layout"
  366.     s.clean
  367.     
  368.